home *** CD-ROM | disk | FTP | other *** search
/ Easy Personal Web Page / Easy Personal Web Page.iso / UNZIPPER / UNZIP512.ZIP / zipinfo.c < prev    next >
C/C++ Source or Header  |  1994-08-16  |  65KB  |  1,634 lines
  1. /*---------------------------------------------------------------------------
  2.  
  3.   zipinfo.c
  4.  
  5.   This file contains all of the zipfile-listing routines for UnZip, inclu-
  6.   ding the bulk of what used to be the separate program ZipInfo.  All of
  7.   the ZipInfo routines are by Greg Roelofs; list_files is by the usual mish-
  8.   mash of Info-ZIP contributors (see the listing in CONTRIBS).
  9.  
  10.   Contains:  zi_opts()
  11.              zi_end_central()
  12.              zipinfo()
  13.              zi_long()
  14.              zi_short()
  15.              zi_time()
  16.              list_files()
  17.              ratio()
  18.              fnprint()
  19.  
  20.   ---------------------------------------------------------------------------*/
  21.  
  22.  
  23. #include "unzip.h"
  24.  
  25. static char unkn[16];
  26.  
  27. static int ratio OF((ulg uc, ulg c));
  28. static void fnprint OF((void));
  29.  
  30.  
  31. /********************************************/
  32. /*  Strings used in zipinfo.c (UnZip half)  */
  33. /********************************************/
  34.  
  35. /* also referenced in UpdateListBox() in updatelb.c (Windows version) */
  36. char Far HeadersS[] = " Length    Date    Time    Name";
  37. char Far HeadersS1[] = " ------    ----    ----    ----";
  38. char Far HeadersL[] = " Length  Method   Size  Ratio   Date    Time   CRC-32     Name";
  39. char Far HeadersL1[] = " ------  ------   ----  -----   ----    ----   ------     ----";
  40. char Far *Headers[][2] = { {HeadersS, HeadersS1}, {HeadersL, HeadersL1} };
  41.  
  42. static char Far CaseConversion[] = "%s (\"^\" ==> case\n%s   conversion)\n";
  43. static char Far CompFactorStr[] = "%c%d%%";
  44. static char Far CompMethodUnknown[] = "Unk:%03d";
  45. #ifdef MSWIN
  46.    static char Far LongHdrStats[] =
  47.      "%7lu  %-7s%7lu %4s  %02u-%02u-%02u  %02u:%02u  %08lx  %c%s";
  48.    static char Far LongFileHeader[] =
  49.      "%7lu         %7lu %4s                              %-7u";
  50.    static char Far ShortHdrStats[] = "%7lu  %02u-%02u-%02u  %02u:%02u  %c%s";
  51.    static char Far ShortFileHeader[] = "%7lu                    %-7u";
  52. #else /* !MSWIN */
  53.    static char Far LongHdrStats[] =
  54.      "%7lu  %-7s%7lu %4s  %02u-%02u-%02u  %02u:%02u  %08lx  %c";
  55.    static char Far ShortHdrStats[] = "%7lu  %02u-%02u-%02u  %02u:%02u  %c";
  56.    static char Far LongFileHeader[] =
  57.      " ------          ------  ---                         \
  58.      -------\n%7lu         %7lu %4s                              %-7u\n";
  59.    static char Far ShortFileHeader[] =
  60.      " ------                    -------\n%7lu                    %-7u\n";
  61. #endif /* ?MSWIN */
  62.  
  63.  
  64.  
  65. #ifndef NO_ZIPINFO  /* strings use up too much space in small-memory systems */
  66.  
  67. /* Define OS-specific attributes for use on ALL platforms--the S_xxxx
  68.  * versions of these are defined differently (or not defined) by different
  69.  * compilers and operating systems. */
  70.  
  71. #define UNX_IFMT       0170000     /* Unix file type mask */
  72. #define UNX_IFDIR      0040000     /* Unix directory */
  73. #define UNX_IFREG      0100000     /* Unix regular file */
  74. #define UNX_IFSOCK     0140000     /* Unix socket (BSD, not SysV or Amiga) */
  75. #define UNX_IFLNK      0120000     /* Unix symbolic link (not SysV, Amiga) */
  76. #define UNX_IFBLK      0060000     /* Unix block special       (not Amiga) */
  77. #define UNX_IFCHR      0020000     /* Unix character special   (not Amiga) */
  78. #define UNX_IFIFO      0010000     /* Unix fifo    (BCC, not MSC or Amiga) */
  79. #define UNX_ISUID      04000       /* Unix set user id on execution */
  80. #define UNX_ISGID      02000       /* Unix set group id on execution */
  81. #define UNX_ISVTX      01000       /* Unix directory permissions control */
  82. #define UNX_ENFMT      UNX_ISGID   /* Unix record locking enforcement flag */
  83. #define UNX_IRWXU      00700       /* Unix read, write, execute: owner */
  84. #define UNX_IRUSR      00400       /* Unix read permission: owner */
  85. #define UNX_IWUSR      00200       /* Unix write permission: owner */
  86. #define UNX_IXUSR      00100       /* Unix execute permission: owner */
  87. #define UNX_IRWXG      00070       /* Unix read, write, execute: group */
  88. #define UNX_IRGRP      00040       /* Unix read permission: group */
  89. #define UNX_IWGRP      00020       /* Unix write permission: group */
  90. #define UNX_IXGRP      00010       /* Unix execute permission: group */
  91. #define UNX_IRWXO      00007       /* Unix read, write, execute: other */
  92. #define UNX_IROTH      00004       /* Unix read permission: other */
  93. #define UNX_IWOTH      00002       /* Unix write permission: other */
  94. #define UNX_IXOTH      00001       /* Unix execute permission: other */
  95.  
  96. #define VMS_IRUSR      UNX_IRUSR   /* VMS read/owner */
  97. #define VMS_IWUSR      UNX_IWUSR   /* VMS write/owner */
  98. #define VMS_IXUSR      UNX_IXUSR   /* VMS execute/owner */
  99. #define VMS_IRGRP      UNX_IRGRP   /* VMS read/group */
  100. #define VMS_IWGRP      UNX_IWGRP   /* VMS write/group */
  101. #define VMS_IXGRP      UNX_IXGRP   /* VMS execute/group */
  102. #define VMS_IROTH      UNX_IROTH   /* VMS read/other */
  103. #define VMS_IWOTH      UNX_IWOTH   /* VMS write/other */
  104. #define VMS_IXOTH      UNX_IXOTH   /* VMS execute/other */
  105.  
  106. #define AMI_IFMT       06000       /* Amiga file type mask */
  107. #define AMI_IFDIR      04000       /* Amiga directory */
  108. #define AMI_IFREG      02000       /* Amiga regular file */
  109. #define AMI_IHIDDEN    00200       /* to be supported in AmigaDOS 3.x */
  110. #define AMI_ISCRIPT    00100       /* executable script (text command file) */
  111. #define AMI_IPURE      00040       /* allow loading into resident memory */
  112. #define AMI_IARCHIVE   00020       /* not modified since bit was last set */
  113. #define AMI_IREAD      00010       /* can be opened for reading */
  114. #define AMI_IWRITE     00004       /* can be opened for writing */
  115. #define AMI_IEXECUTE   00002       /* executable image, a loadable runfile */
  116. #define AMI_IDELETE    00001       /* can be deleted */
  117.  
  118. /* extra-field ID values: */
  119. #define EF_AV        0x0007   /* PKWARE authenticity verification */
  120. #define EF_OS2       0x0009   /* OS/2 extended attributes */
  121. #define EF_PKVMS     0x000c   /* PKWARE's VMS ID */
  122. #define EF_IZVMS     0x4d49   /* Info-ZIP's VMS ID ("IM") */
  123. #define EF_ASIUNIX   0x756e   /* ASi/PKWARE's Unix ID ("IM") */
  124. #define EF_SPARK     0x4341   /* David Pilling's Acorn/SparkFS ID ("AC") */
  125.  
  126. #define LFLAG  3   /* short "ls -l" type listing */
  127.  
  128. static int   zi_long   OF((void));
  129. static int   zi_short  OF((void));
  130. static char *zi_time   OF((ush *datez, ush *timez));
  131.  
  132.  
  133. /**********************************************/
  134. /*  Strings used in zipinfo.c (ZipInfo half)  */
  135. /**********************************************/
  136.  
  137. static char Far LongHeader[] = "Archive:  %s   %ld bytes   %d file%s\n";
  138. static char Far ShortHeader[] = "Archive:  %s   %ld   %d\n";
  139. static char Far EndCentDirRec[] = "\nEnd-of-central-directory record:\n";
  140. static char Far LineSeparators[] = "-------------------------------\n\n";
  141. static char Far ActOffsetCentDir[] = "\
  142.   Actual offset of end-of-central-dir record:   %9ld (%.8lXh)\n\
  143.   Expected offset of end-of-central-dir record: %9ld (%.8lXh)\n\
  144.   (based on the length of the central directory and its expected offset)\n\n";
  145. static char Far SinglePartArchive[] = "\
  146.   This zipfile constitutes the sole disk of a single-part archive; its\n\
  147.   central directory contains %u %s.  The central directory is %lu\n\
  148.   (%.8lXh) bytes long, and its (expected) offset in bytes from the\n\
  149.   beginning of the zipfile is %lu (%.8lXh).\n\n";
  150. static char Far MultiPartArchive[] = "\
  151.   This zipfile constitutes disk %u of a multi-part archive.  The central\n\
  152.   directory starts on disk %u; %u of its entries %s contained within\n\
  153.   this zipfile, out of a total of %u %s.  The entire central\n\
  154.   directory is %lu (%.8lXh) bytes long, and its offset in bytes from\n\
  155.   the beginning of the zipfile in which it begins is %lu (%.8lXh).\n\n";
  156. static char Far NoZipfileComment[] = "  There is no zipfile comment.\n";
  157. static char Far ZipfileCommentDesc[] =
  158.   "  The zipfile comment is %u bytes long and contains the following text:\n\n";
  159. static char Far ZipfileCommBegin[] =
  160.  "======================== zipfile comment begins ==========================\n";
  161. static char Far ZipfileCommEnd[] =
  162.  "========================= zipfile comment ends ===========================\n";
  163. static char Far ZipfileCommTrunc2[] = "\n  The zipfile comment is truncated.\n";
  164. static char Far ZipfileCommTruncMsg[] =
  165.   "\ncaution:  zipfile comment truncated\n";
  166.  
  167. #ifdef T20_VMS
  168.    static char Far CentralDirEntry[] = "\nCentral directory entry #%d:\n";
  169. #else
  170.    static char Far CentralDirEntry[] = "%s\nCentral directory entry #%d:\n";
  171. #endif
  172.  
  173. static char Far CentralDirLines[] = "---------------------------\n\n";
  174. static char Far ZipfileStats[] = 
  175.   "%d file%s, %lu bytes uncompressed, %lu bytes compressed:  %s%d.%d%%\n";
  176.  
  177. /* zi_long() strings */
  178. static char Far OS_FAT[] = "MS-DOS, OS/2 or NT FAT";
  179. static char Far OS_Amiga[] = "Amiga";
  180. static char Far OS_VAXVMS[] = "VAX VMS";
  181. static char Far OS_Unix[] = "Unix";
  182. static char Far OS_VMCMS[] = "VM/CMS";
  183. static char Far OS_AtariST[] = "Atari ST";
  184. static char Far OS_HPFS[] = "OS/2 or NT HPFS";
  185. static char Far OS_Macintosh[] = "Macintosh";
  186. static char Far OS_ZSystem[] = "Z-System";
  187. static char Far OS_CPM[] = "CP/M";
  188. static char Far OS_TOPS20[] = "TOPS-20";
  189. static char Far OS_NTFS[] = "NT NTFS";
  190. static char Far OS_QDOS[] = "QDOS (maybe)";
  191. static char Far OS_Acorn[] = "Acorn RISCOS";
  192.  
  193. static char Far MthdNone[] = "none (stored)";
  194. static char Far MthdShrunk[] = "shrunk";
  195. static char Far MthdRedF1[] = "reduced (factor 1)";
  196. static char Far MthdRedF2[] = "reduced (factor 2)";
  197. static char Far MthdRedF3[] = "reduced (factor 3)";
  198. static char Far MthdRedF4[] = "reduced (factor 4)";
  199. static char Far MthdImplode[] = "imploded";
  200. static char Far MthdToken[] = "tokenized";
  201. static char Far MthdDeflate[] = "deflated";
  202.  
  203. static char Far ExtraBytesPreceding[] =
  204.   "  There are an extra %ld bytes preceding this file.\n\n";
  205.  
  206. static char Far Unknown[] = "unknown (%d)";
  207.  
  208. static char Far HostOS[] =
  209.   "\n  host operating system (created on):               %s\n";
  210. static char Far EncodeSWVer[] =
  211.   "  version of encoding software:                     %d.%d\n";
  212. static char Far MinOSCompReq[] =
  213.   "  minimum operating system compatibility required:  %s\n";
  214. static char Far MinSWVerReq[] =
  215.   "  minimum software version required to extract:     %d.%d\n";
  216. static char Far CompressMethod[] =
  217.   "  compression method:                               %s\n";
  218. static char Far SlideWindowSizeImplode[] =
  219.   "  size of sliding dictionary (implosion):           %cK\n";
  220. static char Far ShannonFanoTrees[] =
  221.   "  number of Shannon-Fano trees (implosion):         %c\n";
  222. static char Far CompressSubtype[] =
  223.   "  compression sub-type (deflation):                 %s\n";
  224. static char Far FileSecurity[] =
  225.   "  file security status:                             %sencrypted\n";
  226. static char Far ExtendedLocalHdr[] =
  227.   "  extended local header:                            %s\n";
  228. static char Far FileModDate[] =
  229.   "  file last modified on:                            %s\n";
  230. static char Far CRC32Value[] =
  231.   "  32-bit CRC value (hex):                           %.8lx\n";
  232. static char Far CompressedFileSize[] =
  233.   "  compressed size:                                  %lu bytes\n";
  234. static char Far UncompressedFileSize[] =
  235.   "  uncompressed size:                                %lu bytes\n";
  236. static char Far FilenameLength[] =
  237.   "  length of filename:                               %u characters\n";
  238. static char Far ExtraFieldLength[] =
  239.   "  length of extra field:                            %u bytes\n";
  240. static char Far FileCommentLength[] =
  241.   "  length of file comment:                           %u characters\n";
  242. static char Far FileDiskNum[] =
  243.   "  disk number on which file begins:                 disk %u\n";
  244. static char Far ApparentFileType[] =
  245.   "  apparent file type:                               %s\n";
  246. static char Far VMSFileAttributes[] =
  247.   "  VMS file attributes (%06o octal):               %s\n";
  248. static char Far AmigaFileAttributes[] =
  249.   "  Amiga file attributes (%06o octal):             %s\n";
  250. static char Far UnixFileAttributes[] =
  251.   "  Unix file attributes (%06o octal):              %s\n";
  252. static char Far NonMSDOSFileAttributes[] =
  253.   "  non-MSDOS external file attributes:               %06lX hex\n";
  254. static char Far MSDOSFileAttributes[] =
  255.   "  MS-DOS file attributes (%02X hex):                  none\n";
  256. static char Far MSDOSFileAttributesRO[] =
  257.   "  MS-DOS file attributes (%02X hex):                  read-only\n";
  258. static char Far MSDOSFileAttributesAlpha[] =
  259.   "  MS-DOS file attributes (%02X hex):                  %s%s%s%s%s%s\n";
  260. static char Far LocalHeaderOffset[] =
  261.   "  offset of local header from start of archive:     %lu (%.8lXh) bytes\n";
  262. static char Far ExtraFieldType[] = "\n\
  263.   The central-directory extra field has ID 0x%04x (%s) and has %u\n\
  264.   data bytes";
  265. static char Far OS2EAs[] = "\
  266. .  The local extra field has %lu bytes of OS/2 extended\n\
  267.   attributes (may not match OS/2 \"dir\" amount due to storage method).";
  268. static char Far First16[] = ".  The first 16 are%s";
  269. static char Far ColonIndent[] = ":\n     ";
  270. static char Far efFormat[] = " %02x";
  271. static char Far efAV[] = "PKWARE AV";
  272. static char Far efOS2[] = "OS/2";
  273. static char Far efPKVMS[] = "PKWARE VMS";
  274. static char Far efIZVMS[] = "Info-ZIP VMS";
  275. static char Far efASiUnix[] = "ASi Unix";
  276. /* static char Far efIZUnix[] = "Info-ZIP Unix"; */
  277. static char Far efSpark[] = "Acorn SparkFS";
  278. static char Far efUnknown[] = "unknown";
  279. static char Far NoFileComment[] = "\n  There is no file comment.\n";
  280. static char Far FileCommBegin[] = "\n\
  281. ------------------------- file comment begins ----------------------------\n";
  282. static char Far FileCommEnd[] = "\
  283. -------------------------- file comment ends -----------------------------\n";
  284. static char Far JanMonth[] = "Jan";
  285. static char Far FebMonth[] = "Feb";
  286. static char Far MarMonth[] = "Mar";
  287. static char Far AprMonth[] = "Apr";
  288. static char Far MayMonth[] = "May";
  289. static char Far JunMonth[] = "Jun";
  290. static char Far JulMonth[] = "Jul";
  291. static char Far AugMonth[] = "Aug";
  292. static char Far SepMonth[] = "Sep";
  293. static char Far OctMonth[] = "Oct";
  294. static char Far NovMonth[] = "Nov";
  295. static char Far DecMonth[] = "Dec";
  296. static char Far BogusFmt[] = "%03d";
  297. static char Far DMYHMTime[] = "%2u-%s-%02u %02u:%02u";
  298. static char Far YMDHMSTime[] = "%u %s %u %02u:%02u:%02u";
  299. static char Far DecimalTime[] = "%02u%02u%02u.%02u%02u%02u";
  300.  
  301.  
  302.  
  303.  
  304.  
  305. /************************/
  306. /*  Function zi_opts()  */
  307. /************************/
  308.  
  309. int zi_opts(pargc, pargv)
  310.     int *pargc;
  311.     char ***pargv;
  312. {
  313.     char   **argv, *s;
  314.     int    argc, c, error=FALSE, negative=0;
  315.     int    hflag_slmv=TRUE, hflag_2=FALSE;  /* diff options => diff defaults */
  316.     int    tflag_slm=TRUE, tflag_2v=FALSE;
  317.     int    explicit_h=FALSE, explicit_t=FALSE;
  318.  
  319.  
  320. #ifdef MACOS
  321.     lflag = LFLAG;   /* reset default on each call */
  322. #endif
  323.     argc = *pargc;
  324.     argv = *pargv;
  325.  
  326.     while (--argc > 0 && (*++argv)[0] == '-') {
  327.         s = argv[0] + 1;
  328.         while ((c = *s++) != 0) {    /* "!= 0":  prevent Turbo C warning */
  329.             switch (c) {
  330.                 case '-':
  331.                     ++negative;
  332.                     break;
  333.                 case '1':      /* shortest listing:  JUST filenames */
  334.                     if (negative)
  335.                         lflag = -2, negative = 0;
  336.                     else
  337.                         lflag = 1;
  338.                     break;
  339.                 case '2':      /* just filenames, plus headers if specified */
  340.                     if (negative)
  341.                         lflag = -2, negative = 0;
  342.                     else
  343.                         lflag = 2;
  344.                     break;
  345.                 case 'h':      /* header line */
  346.                     if (negative)
  347.                         hflag_2 = hflag_slmv = FALSE, negative = 0;
  348.                     else {
  349.                         hflag_2 = hflag_slmv = explicit_h = TRUE;
  350.                         if (lflag == -1)
  351.                             lflag = 0;
  352.                     }
  353.                     break;
  354.                 case 'l':      /* longer form of "ls -l" type listing */
  355.                     if (negative)
  356.                         lflag = -2, negative = 0;
  357.                     else
  358.                         lflag = 5;
  359.                     break;
  360.                 case 'm':      /* medium form of "ls -l" type listing */
  361.                     if (negative)
  362.                         lflag = -2, negative = 0;
  363.                     else
  364.                         lflag = 4;
  365.                     break;
  366.                 case 's':      /* default:  shorter "ls -l" type listing */
  367.                     if (negative)
  368.                         lflag = -2, negative = 0;
  369.                     else
  370.                         lflag = 3;
  371.                     break;
  372.                 case 't':      /* totals line */
  373.                     if (negative)
  374.                         tflag_2v = tflag_slm = FALSE, negative = 0;
  375.                     else {
  376.                         tflag_2v = tflag_slm = explicit_t = TRUE;
  377.                         if (lflag == -1)
  378.                             lflag = 0;
  379.                     }
  380.                     break;
  381.                 case ('T'):    /* use (sortable) decimal time format */
  382.                     if (negative)
  383.                         T_flag = FALSE, negative = 0;
  384.                     else
  385.                         T_flag = TRUE;
  386.                     break;
  387.                 case 'v':      /* turbo-verbose listing */
  388.                     if (negative)
  389.                         lflag = -2, negative = 0;
  390.                     else
  391.                         lflag = 10;
  392.                     break;
  393.                 case 'z':      /* print zipfile comment */
  394.                     if (negative)
  395.                         zflag = negative = 0;
  396.                     else
  397.                         zflag = 1;
  398.                     break;
  399.                 case 'Z':      /* ZipInfo mode:  ignore */
  400.                     break;
  401.                 default:
  402.                     error = TRUE;
  403.                     break;
  404.             }
  405.         }
  406.     }
  407.     if ((argc-- == 0) || error) {
  408.         *pargc = argc;
  409.         *pargv = argv;
  410.         return usage(error);
  411.     }
  412.  
  413.     /* if no listing options given (or all negated), or if only -h/-t given
  414.      * with individual files specified, use default listing format */
  415.     if ((lflag < 0) || ((argc > 0) && (lflag == 0)))
  416.         lflag = LFLAG;
  417.  
  418.     /* set header and totals flags to default or specified values */
  419.     switch (lflag) {
  420.         case 0:   /* 0:  can only occur if either -t or -h explicitly given; */
  421.         case 2:   /*  therefore set both flags equal to normally false value */
  422.             hflag = hflag_2;
  423.             tflag = tflag_2v;
  424.             break;
  425.         case 1:   /* only filenames, *always* */
  426.             hflag = FALSE;
  427.             tflag = FALSE;
  428.             zflag = FALSE;
  429.             break;
  430.         case 3:
  431.         case 4:
  432.         case 5:
  433.             hflag = ((argc > 0) && !explicit_h)? FALSE : hflag_slmv;
  434.             tflag = ((argc > 0) && !explicit_t)? FALSE : tflag_slm;
  435.             break;
  436.         case 10:
  437.             hflag = hflag_slmv;
  438.             tflag = tflag_2v;
  439.             break;
  440.     }
  441.  
  442.     *pargc = argc;
  443.     *pargv = argv;
  444.     return 0;
  445.  
  446. } /* end function zi_opts() */
  447.  
  448.  
  449.  
  450.  
  451.  
  452. /*******************************/
  453. /*  Function zi_end_central()  */
  454. /*******************************/
  455.  
  456. int zi_end_central()   /* return PK-type error code */
  457. {
  458.     int  error = PK_COOL;
  459.  
  460.  
  461. /*---------------------------------------------------------------------------
  462.     Print out various interesting things about the zipfile.
  463.   ---------------------------------------------------------------------------*/
  464.  
  465.     /* header fits on one line, for anything up to 10GB and 10000 files: */
  466.     if (hflag)
  467.         PRINTF(((int)strlen(zipfn) < 39)?
  468.           LoadFarString(LongHeader) :
  469.           LoadFarString(ShortHeader), zipfn, (long)ziplen,
  470.           ecrec.total_entries_central_dir,
  471.           (ecrec.total_entries_central_dir==1)? "":"s");
  472.  
  473.     /* verbose format */
  474.     if (lflag > 9) {
  475.         PRINTF(LoadFarString(EndCentDirRec));
  476.         PRINTF(LoadFarString(LineSeparators));
  477.  
  478.         PRINTF(LoadFarString(ActOffsetCentDir),
  479.           (long)real_ecrec_offset, (long)real_ecrec_offset,
  480.           (long)expect_ecrec_offset, (long)expect_ecrec_offset);
  481.  
  482.         if (ecrec.number_this_disk == 0) {
  483.             PRINTF(LoadFarString(SinglePartArchive),
  484.               ecrec.total_entries_central_dir,
  485.               (ecrec.total_entries_central_dir == 1)? "entry" : "entries",
  486.               ecrec.size_central_directory, ecrec.size_central_directory,
  487.               ecrec.offset_start_central_directory,
  488.               ecrec.offset_start_central_directory);
  489.         } else {
  490.             PRINTF(LoadFarString(MultiPartArchive),
  491.               ecrec.number_this_disk,
  492.               ecrec.num_disk_with_start_central_dir,
  493.               ecrec.num_entries_centrl_dir_ths_disk,
  494.               (ecrec.num_entries_centrl_dir_ths_disk == 1)? "is" : "are",
  495.               ecrec.total_entries_central_dir,
  496.               (ecrec.total_entries_central_dir == 1) ? "entry" : "entries",
  497.               ecrec.size_central_directory, ecrec.size_central_directory,
  498.               ecrec.offset_start_central_directory,
  499.               ecrec.offset_start_central_directory);
  500.         }
  501.  
  502.     /*-----------------------------------------------------------------------
  503.         Get the zipfile comment, if any, and print it out.  (Comment may be
  504.         up to 64KB long.  May the fleas of a thousand camels infest the arm-
  505.         pits of anyone who actually takes advantage of this fact.)
  506.       -----------------------------------------------------------------------*/
  507.  
  508.         if (!ecrec.zipfile_comment_length)
  509.             PRINTF(LoadFarString(NoZipfileComment));
  510.         else {
  511.             PRINTF(LoadFarString(ZipfileCommentDesc),
  512.               ecrec.zipfile_comment_length );
  513.             PRINTF(LoadFarString(ZipfileCommBegin));
  514.             if (do_string(ecrec.zipfile_comment_length, DISPLAY))
  515.                 error = PK_WARN;
  516.             PRINTF(LoadFarString(ZipfileCommEnd));
  517.             if (error)
  518.                 PRINTF(LoadFarString(ZipfileCommTrunc2));
  519.         } /* endif (comment exists) */
  520.  
  521.     /* non-verbose mode:  print zipfile comment only if requested */
  522.     } else if (zflag && ecrec.zipfile_comment_length) {
  523.         if (do_string(ecrec.zipfile_comment_length,DISPLAY)) {
  524.             FPRINTF(stderr, LoadFarString(ZipfileCommTruncMsg));
  525.             error = PK_WARN;
  526.         }
  527.     } /* endif (verbose) */
  528.  
  529.     return error;
  530.  
  531. } /* end function zi_end_central() */
  532.  
  533.  
  534.  
  535.  
  536.  
  537. /************************/
  538. /*  Function zipinfo()  */
  539. /************************/
  540.  
  541. int zipinfo()   /* return PK-type error code */
  542. {
  543.     int   j, do_this_file=FALSE, error, error_in_archive=PK_COOL;
  544.     int   *fn_matched=NULL, *xn_matched=NULL;
  545.     ush   members=0;
  546.     ulg   tot_csize=0L, tot_ucsize=0L;
  547.  
  548.  
  549. /*---------------------------------------------------------------------------
  550.     Malloc space for check on unmatched filespecs (no big deal if one or both
  551.     are NULL).
  552.   ---------------------------------------------------------------------------*/
  553.  
  554.     if (filespecs > 0  &&
  555.         (fn_matched=(int *)malloc(filespecs*sizeof(int))) != NULL)
  556.         for (j = 0;  j < filespecs;  ++j)
  557.             fn_matched[j] = FALSE;
  558.  
  559.     if (xfilespecs > 0  &&
  560.         (xn_matched=(int *)malloc(xfilespecs*sizeof(int))) != NULL)
  561.         for (j = 0;  j < xfilespecs;  ++j)
  562.             xn_matched[j] = FALSE;
  563.  
  564. /*---------------------------------------------------------------------------
  565.     Set file pointer to start of central directory, then loop through cen-
  566.     tral directory entries.  Check that directory-entry signature bytes are
  567.     actually there (just a precaution), then process the entry.  We know
  568.     the entire central directory is on this disk:  we wouldn't have any of
  569.     this information unless the end-of-central-directory record was on this
  570.     disk, and we wouldn't have gotten to this routine unless this is also
  571.     the disk on which the central directory starts.  In practice, this had
  572.     better be the *only* disk in the archive, but maybe someday we'll add
  573.     multi-disk support.
  574.   ---------------------------------------------------------------------------*/
  575.  
  576.     pInfo->lcflag = 0;    /* used in do_string():  never TRUE in zipinfo mode */
  577.     pInfo->textmode = 0;  /* so one can read on screen (but is it ever used?) */
  578.     newzip = TRUE;        /* for zi_long() check of extra bytes */
  579.  
  580.     for (j = 0;  j < (int)ecrec.total_entries_central_dir;  ++j) {
  581.         if (readbuf(sig, 4) == 0)
  582.             return PK_EOF;
  583.         if (strncmp(sig, central_hdr_sig, 4)) {  /* just to make sure */
  584.             FPRINTF(stderr, LoadFarString(CentSigMsg), j);  /* sig not found */
  585.             return PK_BADERR;
  586.         }
  587.         if ((error = get_cdir_ent()) != PK_COOL)
  588.             return error;       /* only PK_EOF defined */
  589.  
  590.         /* do Amigas (AMIGA_) also have volume labels? */
  591.         if (IS_VOLID(crec.external_file_attributes) &&
  592.             (pInfo->hostnum == FS_FAT_ || pInfo->hostnum == FS_HPFS_ ||
  593.              pInfo->hostnum == FS_NTFS_ || pInfo->hostnum == ATARI_))
  594.             pInfo->vollabel = TRUE;
  595.         else
  596.             pInfo->vollabel = FALSE;
  597.  
  598.         if ((error = do_string(crec.filename_length, FILENAME)) != PK_COOL) {
  599.           error_in_archive = error;   /* might be warning */
  600.           if (error > PK_WARN)        /* fatal */
  601.               return error;
  602.         }
  603.  
  604.         if (!process_all_files) {    /* check if specified on command line */
  605.             char  **pfn = pfnames-1;
  606.  
  607.             do_this_file = FALSE;
  608.             while (*++pfn)
  609.                 if (match(filename, *pfn, 0)) {
  610.                     do_this_file = TRUE;
  611.                     if (fn_matched)
  612.                         fn_matched[pfn-pfnames] = TRUE;
  613.                     break;       /* found match, so stop looping */
  614.                 }
  615.             if (do_this_file) {  /* check if this is an excluded file */
  616.                 char  **pxn = pxnames-1;
  617.  
  618.                 while (*++pxn)
  619.                     if (match(filename, *pxn, 0)) {
  620.                         do_this_file = FALSE;
  621.                         if (xn_matched)
  622.                             xn_matched[pxn-pxnames] = TRUE;
  623.                         break;
  624.                     }
  625.             }
  626.         }
  627.  
  628.     /*-----------------------------------------------------------------------
  629.         If current file was specified on command line, or if no names were
  630.         specified, do the listing for this file.  Otherwise, get rid of the
  631.         file comment and go back for the next file.
  632.       -----------------------------------------------------------------------*/
  633.  
  634.         if (process_all_files || do_this_file) {
  635.  
  636.             switch (lflag) {
  637.                 case 1:
  638.                 case 2:
  639.                     fnprint();
  640.                     SKIP_(crec.extra_field_length)
  641.                     SKIP_(crec.file_comment_length)
  642.                     break;
  643.  
  644.                 case 3:
  645.                 case 4:
  646.                 case 5:
  647.                     if ((error = zi_short()) != PK_COOL) {
  648.                         error_in_archive = error;   /* might be warning */
  649.                         if (error > PK_WARN)        /* fatal */
  650.                             return error;
  651.                     }
  652.                     break;
  653.  
  654.                 case 10:
  655. #ifdef T20_VMS  /* GRR:  add cbreak-style "more" */
  656.                     PRINTF(LoadFarString(CentralDirEntry), j);
  657. #else
  658.                     /* formfeed/CR for piping to "more": */
  659.                     PRINTF(LoadFarString(CentralDirEntry), "\014", j);
  660. #endif
  661.                     PRINTF(LoadFarString(CentralDirLines));
  662.  
  663.                     if ((error = zi_long()) != PK_COOL) {
  664.                         error_in_archive = error;   /* might be warning */
  665.                         if (error > PK_WARN)        /* fatal */
  666.                             return error;
  667.                     }
  668.                     break;
  669.  
  670.                 default:
  671.                     SKIP_(crec.extra_field_length)
  672.                     SKIP_(crec.file_comment_length)
  673.                     break;
  674.  
  675.             } /* end switch (lflag) */
  676.  
  677.             tot_csize += crec.csize;
  678.             tot_ucsize += crec.ucsize;
  679.             if (crec.general_purpose_bit_flag & 1)
  680.                 tot_csize -= 12;   /* don't count encryption header */
  681.             ++members;
  682.  
  683.         } else {   /* not listing */
  684.             SKIP_(crec.extra_field_length)
  685.             SKIP_(crec.file_comment_length)
  686.  
  687.         } /* end if (list member?) */
  688.  
  689.     } /* end for-loop (j: member files) */
  690.  
  691. /*---------------------------------------------------------------------------
  692.     Double check that we're back at the end-of-central-directory record.
  693.   ---------------------------------------------------------------------------*/
  694.  
  695.     if (readbuf(sig, 4) == 0)  /* disk error? */
  696.         return PK_EOF;
  697.     if (strncmp(sig, end_central_sig, 4)) {     /* just to make sure again */
  698.         FPRINTF(stderr, LoadFarString(EndSigMsg));  /* didn't find sig */
  699.         error_in_archive = PK_WARN;
  700.     }
  701.  
  702. /*---------------------------------------------------------------------------
  703.     Check that we actually found requested files; if so, print totals.
  704.   ---------------------------------------------------------------------------*/
  705.  
  706.     if (tflag) {
  707.         char *sgn = "";
  708.         int cfactor = ratio(tot_ucsize, tot_csize);
  709.  
  710.         if (cfactor < 0) {
  711.             sgn = "-";
  712.             cfactor = -cfactor;
  713.         }
  714.         PRINTF(LoadFarString(ZipfileStats),
  715.           members, (members==1)? "":"s", tot_ucsize, tot_csize, sgn, cfactor/10,
  716.           cfactor%10);
  717.     }
  718.  
  719. /*---------------------------------------------------------------------------
  720.     Check for unmatched filespecs on command line and print warning if any
  721.     found.
  722.   ---------------------------------------------------------------------------*/
  723.  
  724.     if (fn_matched) {
  725.         for (j = 0;  j < filespecs;  ++j)
  726.             if (!fn_matched[j])
  727.                 FPRINTF(stderr, LoadFarString(FilenameNotMatched),
  728.                   pfnames[j]);
  729.         free(fn_matched);
  730.     }
  731.     if (xn_matched) {
  732.         for (j = 0;  j < xfilespecs;  ++j)
  733.             if (!xn_matched[j])
  734.                 FPRINTF(stderr, LoadFarString(ExclFilenameNotMatched),
  735.                   pxnames[j]);
  736.         free(xn_matched);
  737.     }
  738.     if (members == 0 && error_in_archive <= PK_WARN)
  739.         error_in_archive = PK_FIND;
  740.  
  741.     return error_in_archive;
  742.  
  743. } /* end function zipinfo() */
  744.  
  745.  
  746.  
  747.  
  748.  
  749. #define OS_unkn unkn
  750.  
  751. /************************/
  752. /*  Function zi_long()  */
  753. /************************/
  754.  
  755. static int zi_long()   /* return PK-type error code */
  756. {
  757.     int  error, error_in_archive=PK_COOL;
  758.     ush  hostnum, hostver, extnum, extver, methnum, xattr;
  759.     char workspace[12], attribs[22];
  760.     static char meth_unkn[16];
  761.     static char Far *os[NUM_HOSTS+1] = {
  762.         OS_FAT, OS_Amiga, OS_VAXVMS, OS_Unix, OS_VMCMS, OS_AtariST, OS_HPFS,
  763.         OS_Macintosh, OS_ZSystem, OS_CPM, OS_TOPS20, OS_NTFS, OS_QDOS,
  764.         OS_Acorn, OS_unkn
  765.     };
  766.     static char Far *method[NUM_METHODS+1] = {
  767.         MthdNone, MthdShrunk, MthdRedF1, MthdRedF2, MthdRedF3, MthdRedF4,
  768.         MthdImplode, MthdToken, MthdDeflate, meth_unkn
  769.     };
  770.     static char *dtype[4] = {"normal", "maximum", "fast", "superfast"};
  771.     static ulg endprev;
  772.  
  773.  
  774. /*---------------------------------------------------------------------------
  775.     Check whether there's any extra space inside the zipfile.
  776.   ---------------------------------------------------------------------------*/
  777.  
  778.     if (newzip) {   /* reset if new zipfile; account for multi-part archives */
  779.         endprev = (crec.relative_offset_local_header == 4L)? 4L : 0L;
  780.         newzip = FALSE;
  781.     }
  782.  
  783.     if (crec.relative_offset_local_header != endprev)
  784.         PRINTF(LoadFarString(ExtraBytesPreceding),
  785.           (long)crec.relative_offset_local_header - (long)endprev);
  786.  
  787.     /* calculate endprev for next time around */
  788.     endprev = crec.relative_offset_local_header + 4L + LREC_SIZE +
  789.       crec.filename_length + crec.extra_field_length + crec.file_comment_length
  790.       + crec.csize;
  791.  
  792. /*---------------------------------------------------------------------------
  793.     Print out various interesting things about the compressed file.
  794.   ---------------------------------------------------------------------------*/
  795.  
  796.     hostnum = MIN(crec.version_made_by[1], NUM_HOSTS);
  797.     hostver = crec.version_made_by[0];
  798.     extnum = MIN(crec.version_needed_to_extract[1], NUM_HOSTS);
  799.     extver = crec.version_needed_to_extract[0];
  800.     methnum = MIN(crec.compression_method, NUM_METHODS);
  801.  
  802.     if (hostnum == NUM_HOSTS)
  803.         sprintf(OS_unkn, LoadFarString(Unknown), (int)crec.version_made_by[1]);
  804.     if (methnum == NUM_METHODS)
  805.         sprintf(meth_unkn, LoadFarString(Unknown), crec.compression_method);
  806.  
  807.     PRINTF("  ");  fnprint();
  808.  
  809.     PRINTF(LoadFarString(HostOS), LoadFarStringSmall(os[hostnum]));
  810.     PRINTF(LoadFarString(EncodeSWVer), hostver/10, hostver%10);
  811.     PRINTF(LoadFarString(MinOSCompReq), LoadFarStringSmall(os[extnum]));
  812.     PRINTF(LoadFarString(MinSWVerReq), extver/10, extver%10);
  813.     PRINTF(LoadFarString(CompressMethod), LoadFarStringSmall(method[methnum]));
  814.     if (methnum == IMPLODED) {
  815.         PRINTF(LoadFarString(SlideWindowSizeImplode),
  816.           (crec.general_purpose_bit_flag & 2)? '8' : '4');
  817.         PRINTF(LoadFarString(ShannonFanoTrees),
  818.           (crec.general_purpose_bit_flag & 4)? '3' : '2');
  819.     } else if (methnum == DEFLATED) {
  820.         ush  dnum=(crec.general_purpose_bit_flag>>1) & 3;
  821.         PRINTF(LoadFarString(CompressSubtype), dtype[dnum]);
  822.     }
  823.     PRINTF(LoadFarString(FileSecurity),
  824.       (crec.general_purpose_bit_flag & 1)? "" : "not ");
  825.     PRINTF(LoadFarString(ExtendedLocalHdr),
  826.       (crec.general_purpose_bit_flag & 8)? "yes" : "no");
  827.     /* print upper 3 bits for amusement? */
  828.     PRINTF(LoadFarString(FileModDate),
  829.       zi_time(&crec.last_mod_file_date, &crec.last_mod_file_time));
  830.     PRINTF(LoadFarString(CRC32Value), crec.crc32);
  831.     PRINTF(LoadFarString(CompressedFileSize), crec.csize);
  832.     PRINTF(LoadFarString(UncompressedFileSize), crec.ucsize);
  833.     PRINTF(LoadFarString(FilenameLength), crec.filename_length);
  834.     PRINTF(LoadFarString(ExtraFieldLength), crec.extra_field_length);
  835.     PRINTF(LoadFarString(FileCommentLength), crec.file_comment_length);
  836.     PRINTF(LoadFarString(FileDiskNum), crec.disk_number_start);
  837.     PRINTF(LoadFarString(ApparentFileType),
  838.       (crec.internal_file_attributes & 1)? "text" : "binary");
  839. /*
  840.     PRINTF("  external file attributes (hex):                   %.8lx\n",
  841.       crec.external_file_attributes);
  842.  */
  843.     xattr = (ush)((crec.external_file_attributes >> 16) & 0xFFFF);
  844.     if (hostnum == VMS_) {
  845.         char   *p=attribs, *q=attribs+1;
  846.         int    i, j, k;
  847.  
  848.         for (k = 0;  k < 12;  ++k)
  849.             workspace[k] = 0;
  850.         if (xattr & VMS_IRUSR)
  851.             workspace[0] = 'R';
  852.         if (xattr & VMS_IWUSR) {
  853.             workspace[1] = 'W';
  854.             workspace[3] = 'D';
  855.         }
  856.         if (xattr & VMS_IXUSR)
  857.             workspace[2] = 'E';
  858.         if (xattr & VMS_IRGRP)
  859.             workspace[4] = 'R';
  860.         if (xattr & VMS_IWGRP) {
  861.             workspace[5] = 'W';
  862.             workspace[7] = 'D';
  863.         }
  864.         if (xattr & VMS_IXGRP)
  865.             workspace[6] = 'E';
  866.         if (xattr & VMS_IROTH)
  867.             workspace[8] = 'R';
  868.         if (xattr & VMS_IWOTH) {
  869.             workspace[9] = 'W';
  870.             workspace[11] = 'D';
  871.         }
  872.         if (xattr & VMS_IXOTH)
  873.             workspace[10] = 'E';
  874.  
  875.         *p++ = '(';
  876.         for (k = j = 0;  j < 3;  ++j) {    /* loop over groups of permissions */
  877.             for (i = 0;  i < 4;  ++i, ++k)  /* loop over perms within a group */
  878.                 if (workspace[k])
  879.                     *p++ = workspace[k];
  880.             *p++ = ',';                       /* group separator */
  881.             if (j == 0)
  882.                 while ((*p++ = *q++) != ','); /* system, owner perms are same */
  883.         }
  884.         *p-- = 0;
  885.         *p = ')';   /* overwrite last comma */
  886.         PRINTF(LoadFarString(VMSFileAttributes), xattr, attribs);
  887.  
  888.     } else if (hostnum == AMIGA_) {
  889.         switch (xattr & AMI_IFMT) {
  890.             case AMI_IFDIR:  attribs[0] = 'd';  break;
  891.             case AMI_IFREG:  attribs[0] = '-';  break;
  892.             default:         attribs[0] = '?';  break;
  893.         }
  894.         attribs[1] = (xattr & AMI_IHIDDEN)?   'h' : '-';
  895.         attribs[2] = (xattr & AMI_ISCRIPT)?   's' : '-';
  896.         attribs[3] = (xattr & AMI_IPURE)?     'p' : '-';
  897.         attribs[4] = (xattr & AMI_IARCHIVE)?  'a' : '-';
  898.         attribs[5] = (xattr & AMI_IREAD)?     'r' : '-';
  899.         attribs[6] = (xattr & AMI_IWRITE)?    'w' : '-';
  900.         attribs[7] = (xattr & AMI_IEXECUTE)?  'e' : '-';
  901.         attribs[8] = (xattr & AMI_IDELETE)?   'd' : '-';
  902.         attribs[9] = 0;   /* better dlm the string */
  903.         PRINTF(LoadFarString(AmigaFileAttributes), xattr, attribs);
  904.  
  905.     } else if ((hostnum != FS_FAT_) && (hostnum != FS_HPFS_) &&
  906.                (hostnum != FS_NTFS_) && (hostnum != ATARI_) &&
  907.                (hostnum != ACORN_))
  908.     {                                 /* assume Unix-like */
  909.         switch (xattr & UNX_IFMT) {
  910.             case UNX_IFDIR:   attribs[0] = 'd';  break;
  911.             case UNX_IFREG:   attribs[0] = '-';  break;
  912.             case UNX_IFLNK:   attribs[0] = 'l';  break;
  913.             case UNX_IFBLK:   attribs[0] = 'b';  break;
  914.             case UNX_IFCHR:   attribs[0] = 'c';  break;
  915.             case UNX_IFIFO:   attribs[0] = 'p';  break;
  916.             case UNX_IFSOCK:  attribs[0] = 's';  break;
  917.             default:          attribs[0] = '?';  break;
  918.         }
  919.         attribs[1] = (xattr & UNX_IRUSR)? 'r' : '-';
  920.         attribs[4] = (xattr & UNX_IRGRP)? 'r' : '-';
  921.         attribs[7] = (xattr & UNX_IROTH)? 'r' : '-';
  922.  
  923.         attribs[2] = (xattr & UNX_IWUSR)? 'w' : '-';
  924.         attribs[5] = (xattr & UNX_IWGRP)? 'w' : '-';
  925.         attribs[8] = (xattr & UNX_IWOTH)? 'w' : '-';
  926.  
  927.         if (xattr & UNX_IXUSR)
  928.             attribs[3] = (xattr & UNX_ISUID)? 's' : 'x';
  929.         else
  930.             attribs[3] = (xattr & UNX_ISUID)? 'S' : '-';   /* S = undefined */
  931.         if (xattr & UNX_IXGRP)
  932.             attribs[6] = (xattr & UNX_ISGID)? 's' : 'x';   /* == UNX_ENFMT */
  933.         else
  934.             attribs[6] = (xattr & UNX_ISGID)? 'l' : '-';
  935.         if (xattr & UNX_IXOTH)
  936.             attribs[9] = (xattr & UNX_ISVTX)? 't' : 'x';   /* "sticky bit" */
  937.         else
  938.             attribs[9] = (xattr & UNX_ISVTX)? 'T' : '-';   /* T = undefined */
  939.         attribs[10] = 0;
  940.  
  941.         PRINTF(LoadFarString(UnixFileAttributes), xattr, attribs);
  942.  
  943.     } else {
  944.         PRINTF(LoadFarString(NonMSDOSFileAttributes),
  945.             crec.external_file_attributes >> 8);
  946.  
  947.     } /* endif (hostnum: external attributes format) */
  948.  
  949.     if ((xattr=(ush)(crec.external_file_attributes & 0xFF)) == 0)
  950.         PRINTF(LoadFarString(MSDOSFileAttributes), xattr);
  951.     else if (xattr == 1)
  952.         PRINTF(LoadFarString(MSDOSFileAttributesRO), xattr);
  953.     else
  954.         PRINTF(LoadFarString(MSDOSFileAttributesAlpha),
  955.           xattr, (xattr&1)?"rdo ":"", (xattr&2)?"hid ":"", (xattr&4)?"sys ":"",
  956.           (xattr&8)?"lab ":"", (xattr&16)?"dir ":"", (xattr&32)?"arc":"");
  957.     PRINTF(LoadFarString(LocalHeaderOffset),
  958.       crec.relative_offset_local_header, crec.relative_offset_local_header);
  959.  
  960. /*---------------------------------------------------------------------------
  961.     Skip the extra field, if any, and print the file comment, if any (the
  962.     filename has already been printed, above).  That finishes up this file
  963.     entry...
  964.   ---------------------------------------------------------------------------*/
  965.  
  966.     if (crec.extra_field_length > 0) {
  967.         ush ef_id, ef_datalen;
  968.  
  969.         if ((error = do_string(crec.extra_field_length, EXTRA_FIELD)) != 0) {
  970.             error_in_archive = error;
  971.             if (error > PK_WARN)   /* fatal:  can't continue */
  972.                 return error;
  973.         }
  974.         if (extra_field == (uch *)NULL)
  975.             return PK_ERR;   /* not consistent with crec length */
  976.         ef_id = makeword(extra_field);
  977.         ef_datalen = makeword(&extra_field[2]);
  978.         switch (ef_id) {
  979.             case EF_AV:
  980.                 PRINTF(LoadFarString(ExtraFieldType), ef_id,
  981.                   LoadFarStringSmall(efAV), ef_datalen);
  982.                 break;
  983.             case EF_OS2:
  984.                 PRINTF(LoadFarString(ExtraFieldType), ef_id,
  985.                   LoadFarStringSmall(efOS2), ef_datalen);
  986. /* GRR:  should check that ef_datalen really 4 and not 2 before doing this: */
  987.                 PRINTF(LoadFarString(OS2EAs), makelong(&extra_field[4]));
  988.                 break;
  989.             case EF_PKVMS:
  990.                 PRINTF(LoadFarString(ExtraFieldType), ef_id,
  991.                   LoadFarStringSmall(efPKVMS), ef_datalen);
  992.                 break;
  993.             case EF_IZVMS:
  994.                 PRINTF(LoadFarString(ExtraFieldType), ef_id,
  995.                   LoadFarStringSmall(efIZVMS), ef_datalen);
  996.                 break;
  997.             case EF_ASIUNIX:
  998.                 PRINTF(LoadFarString(ExtraFieldType), ef_id,
  999.                   LoadFarStringSmall(efASiUnix), ef_datalen);
  1000.                 break;
  1001.             case EF_SPARK:
  1002.                 PRINTF(LoadFarString(ExtraFieldType), ef_id,
  1003.                   LoadFarStringSmall(efSpark), ef_datalen);
  1004.                 break;
  1005.             default:
  1006.                 PRINTF(LoadFarString(ExtraFieldType), ef_id,
  1007.                   LoadFarStringSmall(efUnknown), ef_datalen);
  1008.                 break;
  1009.         }
  1010.         if (ef_id != EF_OS2) {
  1011.             ush i, n;
  1012.  
  1013.             if (ef_datalen <= 16) {
  1014.                 PRINTF(LoadFarString(ColonIndent));
  1015. /* GRR:  should double-check that datalen <= crec.extra_field_length - 4 */
  1016.                 n = ef_datalen;
  1017.             } else {
  1018.                 PRINTF(LoadFarString(First16),
  1019.                   LoadFarStringSmall(ColonIndent));
  1020.                 n = 16;
  1021.             }
  1022.             for (i = 0;  i < n;  ++i)
  1023.                 PRINTF(LoadFarString(efFormat), extra_field[i+4]);
  1024.         }
  1025.         PRINTF("\n");
  1026.     }
  1027.  
  1028.     if (!crec.file_comment_length)
  1029.         PRINTF(LoadFarString(NoFileComment));
  1030.     else {
  1031.         PRINTF(LoadFarString(FileCommBegin));
  1032.         if ((error = do_string(crec.file_comment_length, DISPLAY)) != PK_COOL) {
  1033.           error_in_archive = error;   /* might be warning */
  1034.           if (error > PK_WARN)   /* fatal */
  1035.               return error;
  1036.         }
  1037.         PRINTF(LoadFarString(FileCommEnd));
  1038.     }
  1039.  
  1040.     return error_in_archive;
  1041.  
  1042. } /* end function zi_long() */
  1043.  
  1044.  
  1045.  
  1046.  
  1047.  
  1048. /*************************/
  1049. /*  Function zi_short()  */
  1050. /*************************/
  1051.  
  1052. static int zi_short()   /* return PK-type error code */
  1053. {
  1054.     int         k, error, error_in_archive=PK_COOL;
  1055.     ush         methnum, hostnum, hostver, xattr;
  1056.     char        *p, workspace[12], attribs[16];
  1057.     static char impl[5]="i#:#", defl[5]="def#";
  1058.     static char dtype[5]="NXFS";  /* normal, maximum, fast, superfast */
  1059.     static char *os[NUM_HOSTS+1] = {
  1060.         "fat", "ami", "vms", "unx", "cms", "atr", "hpf", "mac", "zzz",
  1061.         "cpm", "t20", "ntf", "qds", "aco", "???"
  1062.     };
  1063.     static char *method[NUM_METHODS+1] = {
  1064.         "stor", "shrk", "re:1", "re:2", "re:3", "re:4", impl, "tokn",
  1065.         defl, unkn
  1066.     };
  1067.  
  1068.  
  1069. /*---------------------------------------------------------------------------
  1070.     Print out various interesting things about the compressed file.
  1071.   ---------------------------------------------------------------------------*/
  1072.  
  1073.     methnum = MIN(crec.compression_method, NUM_METHODS);
  1074.     hostnum = MIN(crec.version_made_by[1], NUM_HOSTS);
  1075.     hostver = crec.version_made_by[0];
  1076. /*
  1077.     extnum = MIN(crec.version_needed_to_extract[1], NUM_HOSTS);
  1078.     extver = crec.version_needed_to_extract[0];
  1079.  */
  1080.  
  1081.     if (methnum == IMPLODED) {
  1082.         impl[1] = (char) ((crec.general_purpose_bit_flag & 2)? '8' : '4');
  1083.         impl[3] = (char) ((crec.general_purpose_bit_flag & 4)? '3' : '2');
  1084.     } else if (methnum == DEFLATED) {
  1085.         ush  dnum=(crec.general_purpose_bit_flag>>1) & 3;
  1086.         defl[3] = dtype[dnum];
  1087.     } else if (methnum == NUM_METHODS) {   /* unknown */
  1088.         sprintf(unkn, "u%03d", crec.compression_method);
  1089.     }
  1090.  
  1091.     for (k = 0;  k < 15;  ++k)
  1092.         attribs[k] = ' ';
  1093.     attribs[15] = 0;
  1094.  
  1095.     xattr = (ush)((crec.external_file_attributes >> 16) & 0xFFFF);
  1096.     switch (hostnum) {
  1097.         case VMS_:
  1098.             {   int    i, j;
  1099.  
  1100.                 for (k = 0;  k < 12;  ++k)
  1101.                     workspace[k] = 0;
  1102.                 if (xattr & VMS_IRUSR)
  1103.                     workspace[0] = 'R';
  1104.                 if (xattr & VMS_IWUSR) {
  1105.                     workspace[1] = 'W';
  1106.                     workspace[3] = 'D';
  1107.                 }
  1108.                 if (xattr & VMS_IXUSR)
  1109.                     workspace[2] = 'E';
  1110.                 if (xattr & VMS_IRGRP)
  1111.                     workspace[4] = 'R';
  1112.                 if (xattr & VMS_IWGRP) {
  1113.                     workspace[5] = 'W';
  1114.                     workspace[7] = 'D';
  1115.                 }
  1116.                 if (xattr & VMS_IXGRP)
  1117.                   workspace[6] = 'E';
  1118.                 if (xattr & VMS_IROTH)
  1119.                     workspace[8] = 'R';
  1120.                 if (xattr & VMS_IWOTH) {
  1121.                     workspace[9] = 'W';
  1122.                     workspace[11] = 'D';
  1123.                 }
  1124.                 if (xattr & VMS_IXOTH)
  1125.                     workspace[10] = 'E';
  1126.  
  1127.                 p = attribs;
  1128.                 for (k = j = 0;  j < 3;  ++j) {     /* groups of permissions */
  1129.                     for (i = 0;  i < 4;  ++i, ++k)  /* perms within a group */
  1130.                         if (workspace[k])
  1131.                             *p++ = workspace[k];
  1132.                     *p++ = ',';                     /* group separator */
  1133.                 }
  1134.                 *--p = ' ';   /* overwrite last comma */
  1135.                 if ((p - attribs) < 12)
  1136.                     sprintf(&attribs[12], "%d.%d", hostver/10, hostver%10);
  1137.             }
  1138.             break;
  1139.  
  1140.         case FS_FAT_:
  1141.         case FS_HPFS_:
  1142.         case FS_NTFS_:
  1143.         case ATARI_:
  1144.         case ACORN_:
  1145.             xattr = (ush)(crec.external_file_attributes & 0xFF);
  1146.             sprintf(attribs, ".r.-...     %d.%d", hostver/10, hostver%10);
  1147.             attribs[2] = (xattr & 0x01)? '-' : 'w';
  1148.             attribs[5] = (xattr & 0x02)? 'h' : '-';
  1149.             attribs[6] = (xattr & 0x04)? 's' : '-';
  1150.             attribs[4] = (xattr & 0x20)? 'a' : '-';
  1151.             if (xattr & 0x10) {
  1152.                 attribs[0] = 'd';
  1153.                 attribs[3] = 'x';
  1154.             } else
  1155.                 attribs[0] = '-';
  1156.             if (IS_VOLID(xattr))
  1157.                 attribs[0] = 'V';
  1158.             else if ((p = strrchr(filename, '.')) != (char *)NULL) {
  1159.                 ++p;
  1160.                 if (STRNICMP(p, "com", 3) == 0 || STRNICMP(p, "exe", 3) == 0 ||
  1161.                     STRNICMP(p, "btm", 3) == 0 || STRNICMP(p, "cmd", 3) == 0 ||
  1162.                     STRNICMP(p, "bat", 3) == 0)
  1163.                     attribs[3] = 'x';
  1164.             }
  1165.             break;
  1166.  
  1167.         case AMIGA_:
  1168.             switch (xattr & AMI_IFMT) {
  1169.                 case AMI_IFDIR:  attribs[0] = 'd';  break;
  1170.                 case AMI_IFREG:  attribs[0] = '-';  break;
  1171.                 default:         attribs[0] = '?';  break;
  1172.             }
  1173.             attribs[1] = (xattr & AMI_IHIDDEN)?   'h' : '-';
  1174.             attribs[2] = (xattr & AMI_ISCRIPT)?   's' : '-';
  1175.             attribs[3] = (xattr & AMI_IPURE)?     'p' : '-';
  1176.             attribs[4] = (xattr & AMI_IARCHIVE)?  'a' : '-';
  1177.             attribs[5] = (xattr & AMI_IREAD)?     'r' : '-';
  1178.             attribs[6] = (xattr & AMI_IWRITE)?    'w' : '-';
  1179.             attribs[7] = (xattr & AMI_IEXECUTE)?  'e' : '-';
  1180.             attribs[8] = (xattr & AMI_IDELETE)?   'd' : '-';
  1181.             sprintf(&attribs[12], "%d.%d", hostver/10, hostver%10);
  1182.             break;
  1183.  
  1184.         default:   /* assume Unix-like */
  1185.             switch (xattr & UNX_IFMT) {
  1186.                 case UNX_IFDIR:   attribs[0] = 'd';  break;
  1187.                 case UNX_IFREG:   attribs[0] = '-';  break;
  1188.                 case UNX_IFLNK:   attribs[0] = 'l';  break;
  1189.                 case UNX_IFBLK:   attribs[0] = 'b';  break;
  1190.                 case UNX_IFCHR:   attribs[0] = 'c';  break;
  1191.                 case UNX_IFIFO:   attribs[0] = 'p';  break;
  1192.                 case UNX_IFSOCK:  attribs[0] = 's';  break;
  1193.                 default:          attribs[0] = '?';  break;
  1194.             }
  1195.             attribs[1] = (xattr & UNX_IRUSR)? 'r' : '-';
  1196.             attribs[4] = (xattr & UNX_IRGRP)? 'r' : '-';
  1197.             attribs[7] = (xattr & UNX_IROTH)? 'r' : '-';
  1198.             attribs[2] = (xattr & UNX_IWUSR)? 'w' : '-';
  1199.             attribs[5] = (xattr & UNX_IWGRP)? 'w' : '-';
  1200.             attribs[8] = (xattr & UNX_IWOTH)? 'w' : '-';
  1201.  
  1202.             if (xattr & UNX_IXUSR)
  1203.                 attribs[3] = (xattr & UNX_ISUID)? 's' : 'x';
  1204.             else
  1205.                 attribs[3] = (xattr & UNX_ISUID)? 'S' : '-';  /* S==undefined */
  1206.             if (xattr & UNX_IXGRP)
  1207.                 attribs[6] = (xattr & UNX_ISGID)? 's' : 'x';  /* == UNX_ENFMT */
  1208.             else
  1209.                 /* attribs[6] = (xattr & UNX_ISGID)? 'l' : '-';  real 4.3BSD */
  1210.                 attribs[6] = (xattr & UNX_ISGID)? 'S' : '-';  /* SunOS 4.1.x */
  1211.             if (xattr & UNX_IXOTH)
  1212.                 attribs[9] = (xattr & UNX_ISVTX)? 't' : 'x';  /* "sticky bit" */
  1213.             else
  1214.                 attribs[9] = (xattr & UNX_ISVTX)? 'T' : '-';  /* T==undefined */
  1215.  
  1216.             sprintf(&attribs[12], "%d.%d", hostver/10, hostver%10);
  1217.             break;
  1218.  
  1219.     } /* end switch (hostnum: external attributes format) */
  1220.  
  1221.     PRINTF("%s %s %7lu %c%c", attribs, os[hostnum], crec.ucsize,
  1222.       (crec.general_purpose_bit_flag & 1)?
  1223.       ((crec.internal_file_attributes & 1)? 'T' : 'B') :   /* encrypted */
  1224.       ((crec.internal_file_attributes & 1)? 't' : 'b'),    /* plaintext */
  1225.       (crec.general_purpose_bit_flag & 8)? (crec.extra_field_length? 'X' : 'l')
  1226.                                         : (crec.extra_field_length? 'x' : '-'));
  1227.     if (lflag == 4) {
  1228.         ulg csiz = crec.csize;
  1229.  
  1230.         if (crec.general_purpose_bit_flag & 1)
  1231.             csiz -= 12;    /* if encrypted, don't count encryption header */
  1232.         PRINTF("%3d%%", (ratio(crec.ucsize,csiz) + 5)/10);
  1233.     } else if (lflag == 5)
  1234.         PRINTF(" %7lu", crec.csize);
  1235.  
  1236.     PRINTF(" %s %s ", method[methnum],
  1237.       zi_time(&crec.last_mod_file_date, &crec.last_mod_file_time));
  1238.     fnprint();
  1239.  
  1240. /*---------------------------------------------------------------------------
  1241.     Skip the extra field and/or the file comment, if any (the filename has
  1242.     already been printed, above).  That finishes up this file entry...
  1243.   ---------------------------------------------------------------------------*/
  1244.  
  1245.     SKIP_(crec.extra_field_length)
  1246.     SKIP_(crec.file_comment_length)
  1247.  
  1248.     return error_in_archive;
  1249.  
  1250. } /* end function zi_short() */
  1251.  
  1252.  
  1253.  
  1254.  
  1255.  
  1256. /************************/
  1257. /*  Function zi_time()  */
  1258. /************************/
  1259.  
  1260. static char *zi_time(datez, timez)
  1261.     ush *datez, *timez;
  1262. {
  1263.     ush yr, mo, dy, hh, mm, ss;
  1264.     static char d_t_str[21], bogus[4];
  1265.     static char Far *month[13] = {
  1266.         bogus, JanMonth, FebMonth, MarMonth, AprMonth, MayMonth, JunMonth,
  1267.         JulMonth, AugMonth, SepMonth, OctMonth, NovMonth, DecMonth
  1268.     };
  1269.  
  1270.  
  1271.  
  1272. /*---------------------------------------------------------------------------
  1273.     Convert the file-modification date and time info to a string of the form
  1274.     "1991 Feb 23 17:15:00" or "23-Feb-91 17:15," depending on value of lflag.
  1275.   ---------------------------------------------------------------------------*/
  1276.  
  1277.     yr = ((*datez >> 9) & 0x7f) + 80;
  1278.     mo = ((*datez >> 5) & 0x0f);
  1279.     dy = *datez & 0x1f;
  1280.  
  1281.     hh = (*timez >> 11) & 0x1f;
  1282.     mm = (*timez >> 5) & 0x3f;
  1283.     ss = (*timez & 0x1f) * 2;
  1284.  
  1285.     if (mo == 0 || mo > 12) {
  1286.         sprintf(bogus, LoadFarString(BogusFmt), mo);
  1287.         mo = 0;
  1288.     }
  1289.  
  1290.     if (lflag > 9)  /* verbose listing format */
  1291.         sprintf(d_t_str, LoadFarString(YMDHMSTime), yr+1900,
  1292.             LoadFarStringSmall(month[mo]), dy, hh, mm, ss);
  1293.     else if (T_flag)
  1294.         sprintf(d_t_str, LoadFarString(DecimalTime), yr%100, mo, dy, hh, mm,
  1295.           ss);
  1296.     else   /* was:  if ((lflag >= 3) && (lflag <= 5)) */
  1297.         sprintf(d_t_str, LoadFarString(DMYHMTime), dy,
  1298.             LoadFarStringSmall(month[mo]), yr%100, hh, mm);
  1299.  
  1300.     return d_t_str;
  1301.  
  1302. } /* end function zi_time() */
  1303.  
  1304. #endif /* !NO_ZIPINFO */
  1305.  
  1306.  
  1307.  
  1308.  
  1309.  
  1310. /*************************/
  1311. /* Function list_files() */
  1312. /*************************/
  1313.  
  1314. int list_files()    /* return PK-type error code */
  1315. {
  1316.     char sgn, cfactorstr[10];
  1317.     int do_this_file=FALSE, cfactor, error, error_in_archive=PK_COOL;
  1318.     int longhdr=(vflag>1), date_format, methnum;
  1319.     ush j, yr, mo, dy, hh, mm, members=0;
  1320.     ulg csiz, tot_csize=0L, tot_ucsize=0L;
  1321. #ifdef OS2
  1322.     ulg ea_size, tot_easize=0L, tot_eafiles=0L;
  1323. #endif
  1324. #ifdef MSWIN
  1325.     PSTR psLBEntry;  /* list box entry */
  1326. #endif
  1327.     min_info info;
  1328.     static char defl[]="Defl:#", dtype[]="NXFS";   /* see zi_short() */
  1329.     static char *method[NUM_METHODS+1] =
  1330.         {"Stored", "Shrunk", "Reduce1", "Reduce2", "Reduce3", "Reduce4",
  1331.          "Implode", "Token", defl, unkn};
  1332.  
  1333.  
  1334.  
  1335. /*---------------------------------------------------------------------------
  1336.     Unlike extract_or_test_files(), this routine confines itself to the cen-
  1337.     tral directory.  Thus its structure is somewhat simpler, since we can do
  1338.     just a single loop through the entire directory, listing files as we go.
  1339.  
  1340.     So to start off, print the heading line and then begin main loop through
  1341.     the central directory.  The results will look vaguely like the following:
  1342.  
  1343.   Length  Method   Size  Ratio   Date    Time   CRC-32     Name ("^" ==> case
  1344.   ------  ------   ----  -----   ----    ----   ------     ----   conversion)
  1345.    44004  Implode  13041  71%  11-02-89  19:34  8b4207f7   Makefile.UNIX
  1346.     3438  Shrunk    2209  36%  09-15-90  14:07  a2394fd8  ^dos-file.ext
  1347.   ---------------------------------------------------------------------------*/
  1348.  
  1349.     pInfo = &info;
  1350.     date_format = DATE_FORMAT;
  1351.  
  1352. #ifndef MSWIN
  1353.     if (qflag < 2)
  1354.         if (L_flag)
  1355.             PRINTF(LoadFarString(CaseConversion),
  1356.               LoadFarStringSmall(Headers[longhdr][0]),
  1357.               LoadFarStringSmall2(Headers[longhdr][1]));
  1358.         else
  1359.             PRINTF("%s\n%s\n", LoadFarString(Headers[longhdr][0]),
  1360.                    LoadFarStringSmall(Headers[longhdr][1]));
  1361. #endif /* !MSWIN */
  1362.  
  1363.     for (j = 0; j < ecrec.total_entries_central_dir; ++j) {
  1364.  
  1365.         if (readbuf(sig, 4) == 0)
  1366.             return PK_EOF;
  1367.         if (strncmp(sig, central_hdr_sig, 4)) {  /* just to make sure */
  1368.             FPRINTF(stderr, LoadFarString(CentSigMsg), j);   /* sig not found */
  1369.             FPRINTF(stderr, LoadFarString(ReportMsg));  /* check binary xfers */
  1370.             return PK_BADERR;
  1371.         }
  1372.         /* process_cdir_file_hdr() sets pInfo->lcflag: */
  1373.         if ((error = process_cdir_file_hdr()) != PK_COOL)
  1374.             return error;       /* only PK_EOF defined */
  1375.  
  1376.         /*
  1377.          * We could DISPLAY the filename instead of storing (and possibly trun-
  1378.          * cating, in the case of a very long name) and printing it, but that
  1379.          * has the disadvantage of not allowing case conversion--and it's nice
  1380.          * to be able to see in the listing precisely how you have to type each
  1381.          * filename in order for unzip to consider it a match.  Speaking of
  1382.          * which, if member names were specified on the command line, check in
  1383.          * with match() to see if the current file is one of them, and make a
  1384.          * note of it if it is.
  1385.          */
  1386.  
  1387.         if ((error = do_string(crec.filename_length, FILENAME)) != PK_COOL) {
  1388.             error_in_archive = error;             /*  ^--(uses pInfo->lcflag) */
  1389.             if (error > PK_WARN)   /* fatal:  can't continue */
  1390.                 return error;
  1391.         }
  1392.         if (extra_field != (uch *)NULL) {
  1393.             free(extra_field);
  1394.             extra_field = (uch *)NULL;
  1395.         }
  1396.         if ((error = do_string(crec.extra_field_length, EXTRA_FIELD)) != 0) {
  1397.             error_in_archive = error;  
  1398.             if (error > PK_WARN)      /* fatal */
  1399.                 return error;
  1400.         }
  1401.         if (!process_all_files) {   /* check if specified on command line */
  1402.             char **pfn = pfnames-1;
  1403.  
  1404.             do_this_file = FALSE;
  1405.             while (*++pfn)
  1406.                 if (match(filename, *pfn, C_flag)) {
  1407.                     do_this_file = TRUE;
  1408.                     break;       /* found match, so stop looping */
  1409.                 }
  1410.             if (do_this_file) {  /* check if this is an excluded file */
  1411.                 char **pxn = pxnames-1;
  1412.  
  1413.                 while (*++pxn)
  1414.                     if (match(filename, *pxn, C_flag)) {
  1415.                         do_this_file = FALSE;  /* ^-- ignore case in match */
  1416.                         break;
  1417.                     }
  1418.             }
  1419.         }
  1420.         /*
  1421.          * If current file was specified on command line, or if no names were
  1422.          * specified, do the listing for this file.  Otherwise, get rid of the
  1423.          * file comment and go back for the next file.
  1424.          */
  1425.  
  1426.         if (process_all_files || do_this_file) {
  1427.  
  1428.             yr = (((crec.last_mod_file_date >> 9) & 0x7f) + 80) % (unsigned)100;
  1429.             mo = (crec.last_mod_file_date >> 5) & 0x0f;
  1430.             dy = crec.last_mod_file_date & 0x1f;
  1431.  
  1432.             /* permute date so it displays according to national convention */
  1433.             switch (date_format) {
  1434.                 case DF_YMD:
  1435.                     hh = mo; mo = yr; yr = dy; dy = hh;
  1436.                     break;
  1437.                 case DF_DMY:
  1438.                     hh = mo; mo = dy; dy = hh;
  1439.             }
  1440.             hh = (crec.last_mod_file_time >> 11) & 0x1f;
  1441.             mm = (crec.last_mod_file_time >> 5) & 0x3f;
  1442.  
  1443.             csiz = crec.csize;
  1444.             if (crec.general_purpose_bit_flag & 1)
  1445.                 csiz -= 12;   /* if encrypted, don't count encryption header */
  1446.             if ((cfactor = ratio(crec.ucsize, csiz)) < 0) {
  1447.                 sgn = '-';
  1448.                 cfactor = (-cfactor + 5) / 10;
  1449.             } else {
  1450.                 sgn = ' ';
  1451.                 cfactor = (cfactor + 5) / 10;
  1452.             }
  1453.             sprintf(cfactorstr, LoadFarString(CompFactorStr), sgn, cfactor);
  1454.  
  1455.             methnum = MIN(crec.compression_method, NUM_METHODS);
  1456.             if (methnum == DEFLATED)
  1457.                 defl[5] = dtype[(crec.general_purpose_bit_flag>>1) & 3];
  1458.             else if (methnum == NUM_METHODS)
  1459.                 sprintf(unkn, LoadFarString(CompMethodUnknown),
  1460.                     crec.compression_method);
  1461.  
  1462. #if 0       /* GRR/Euro:  add this? */
  1463. #if defined(DOS_NT_OS2) || defined(UNIX)
  1464.             for (p = filename;  *p;  ++p)
  1465.                 if (!isprint(*p))
  1466.                     *p = '?';  /* change non-printable chars to '?' */
  1467. #endif /* DOS_NT_OS2 || UNIX */
  1468. #endif /* 0 */
  1469.  
  1470. #ifdef MSWIN
  1471. #ifdef NEED_EARLY_REDRAW
  1472.             /* turn on listbox redrawing just before adding last line */
  1473.             if (j == (ecrec.total_entries_central_dir-1))
  1474.                 (void)SendMessage(hWndList, WM_SETREDRAW, TRUE, 0L);
  1475. #endif /* NEED_EARLY_REDRAW */
  1476.             psLBEntry =
  1477.               (PSTR)LocalAlloc(LMEM_FIXED, FILNAMSIZ+LONG_FORM_FNAME_INX);
  1478.             /* GRR:  does OemToAnsi filter out escape and CR characters? */
  1479.             OemToAnsi(filename, filename);  /* translate to ANSI */
  1480.             if (longhdr) {
  1481.                 wsprintf(psLBEntry, LoadFarString(LongHdrStats),
  1482.                   crec.ucsize, (LPSTR)method[methnum], csiz, cfactorstr,
  1483.                   mo, dy, yr, hh, mm, crec.crc32, (pInfo->lcflag?'^':' '),
  1484.                   (LPSTR)filename);
  1485.                 SendMessage(hWndList, LB_ADDSTRING, 0,
  1486.                   (LONG)(LPSTR)psLBEntry);
  1487.             } else {
  1488.                 wsprintf(psLBEntry, LoadFarString(ShortHdrStats),
  1489.                   crec.ucsize, mo, dy, yr, hh, mm, (pInfo->lcflag?'^':' '),
  1490.                   (LPSTR)filename);
  1491.                 SendMessage(hWndList, LB_ADDSTRING, 0,
  1492.                   (LONG)(LPSTR)psLBEntry);
  1493.             }
  1494.             LocalFree((HANDLE)psLBEntry);
  1495. #else /* !MSWIN */
  1496.             if (longhdr)
  1497.                 PRINTF(LoadFarString(LongHdrStats),
  1498.                   crec.ucsize, method[methnum], csiz, cfactorstr, mo, dy, yr,
  1499.                   hh, mm, crec.crc32, (pInfo->lcflag?'^':' '));
  1500.             else
  1501.                 PRINTF(LoadFarString(ShortHdrStats), crec.ucsize,
  1502.                   mo, dy, yr, hh, mm, (pInfo->lcflag?'^':' '));
  1503.             fnprint();
  1504. #endif /* ?MSWIN */
  1505.  
  1506.             error = do_string(crec.file_comment_length, QCOND? DISPLAY : SKIP);
  1507.             if (error) {
  1508.                 error_in_archive = error;  /* might be just warning */
  1509.                 if (error > PK_WARN)       /* fatal */
  1510.                     return error;
  1511.             }
  1512.             tot_ucsize += crec.ucsize;
  1513.             tot_csize += csiz;
  1514.             ++members;
  1515. #ifdef OS2
  1516.             if ((ea_size = SizeOfEAs(extra_field)) != 0) {
  1517.                 tot_easize += ea_size;
  1518.                 tot_eafiles++;
  1519.             }
  1520. #endif
  1521.         } else {        /* not listing this file */
  1522.             SKIP_(crec.file_comment_length)
  1523.         }
  1524.     } /* end for-loop (j: files in central directory) */
  1525.  
  1526. /*---------------------------------------------------------------------------
  1527.     Print footer line and totals (compressed size, uncompressed size, number
  1528.     of members in zipfile).
  1529.   ---------------------------------------------------------------------------*/
  1530.  
  1531.     if (qflag < 2) {
  1532.         if ((cfactor = ratio(tot_ucsize, tot_csize)) < 0) {
  1533.             sgn = '-';
  1534.             cfactor = (-cfactor + 5) / 10;
  1535.         } else {
  1536.             sgn = ' ';
  1537.             cfactor = (cfactor + 5) / 10;
  1538.         }
  1539.         sprintf(cfactorstr, LoadFarString(CompFactorStr), sgn, cfactor);
  1540. #ifdef MSWIN
  1541.         /* Display just the totals since the dashed lines get displayed
  1542.          * in UpdateListBox(). Get just enough space to display total. */
  1543.         if (longhdr)
  1544.             wsprintf(lpumb->szTotalsLine,LoadFarString(LongFileHeader), 
  1545.               tot_ucsize, tot_csize, cfactorstr, members);
  1546.         else
  1547.             wsprintf(lpumb->szTotalsLine, LoadFarString(ShortFileHeader), 
  1548.               tot_ucsize, members);
  1549. #else /* !MSWIN */
  1550.         if (longhdr)
  1551.             PRINTF(LoadFarString(LongFileHeader), tot_ucsize, tot_csize, cfactorstr, members);
  1552.         else
  1553.             PRINTF(LoadFarString(ShortFileHeader), tot_ucsize, members);
  1554. #endif /* ?MSWIN */
  1555. #ifdef OS2
  1556.         if (tot_eafiles && tot_easize)
  1557.             PRINTF("\n%ld file%s %ld bytes of EA's attached.\n", tot_eafiles, 
  1558.               tot_eafiles == 1 ? " has" : "s have a total of", tot_easize);
  1559. #endif
  1560.     }
  1561. /*---------------------------------------------------------------------------
  1562.     Double check that we're back at the end-of-central-directory record.
  1563.   ---------------------------------------------------------------------------*/
  1564.  
  1565.     if (readbuf(sig, 4) == 0)
  1566.         return PK_EOF;
  1567.     if (strncmp(sig, end_central_sig, 4)) {     /* just to make sure again */
  1568.         FPRINTF(stderr, LoadFarString(EndSigMsg));  /* didn't find sig */
  1569.         error_in_archive = PK_WARN;
  1570.     }
  1571.     if (members == 0 && error_in_archive <= PK_WARN)
  1572.         error_in_archive = PK_FIND;
  1573.  
  1574.     return error_in_archive;
  1575.  
  1576. } /* end function list_files() */
  1577.  
  1578.  
  1579.  
  1580.  
  1581.  
  1582. /********************/
  1583. /* Function ratio() */
  1584. /********************/
  1585.  
  1586. static int ratio(uc, c)
  1587.     ulg uc, c;
  1588. {
  1589.     ulg denom;
  1590.  
  1591.     if (uc == 0)
  1592.         return 0;
  1593.     if (uc > 2000000L) {    /* risk signed overflow if multiply numerator */
  1594.         denom = uc / 1000L;
  1595.         return ((uc >= c) ?
  1596.             (int) ((uc-c + (denom>>1)) / denom) :
  1597.           -((int) ((c-uc + (denom>>1)) / denom)));
  1598.     } else {             /* ^^^^^^^^ rounding */
  1599.         denom = uc;
  1600.         return ((uc >= c) ?
  1601.             (int) ((1000L*(uc-c) + (denom>>1)) / denom) :
  1602.           -((int) ((1000L*(c-uc) + (denom>>1)) / denom)));
  1603.     }                            /* ^^^^^^^^ rounding */
  1604. }
  1605.  
  1606.  
  1607.  
  1608.  
  1609.  
  1610. /************************/
  1611. /*  Function fnprint()  */
  1612. /************************/
  1613.  
  1614. static void fnprint()    /* print filename (after filtering) and newline */
  1615. {
  1616.     register uch *p = (uch *)filename-1;
  1617.     register uch *q = (uch *)slide;
  1618.  
  1619. #ifdef NATIVE
  1620.     PRINTF("%s", filename);   /* GRR:  can ANSI be used with EBCDIC? */
  1621. #else /* ASCII */
  1622.     while (*++p) {
  1623.         if (*p < 32) {        /* ASCII control character */
  1624.             *q++ = '^';
  1625.             *q++ = *p + 64;
  1626.         } else
  1627.             *q++ = *p;
  1628.     }                    /* filename better not be longer than slide[] ... */
  1629.     *q = '\0';
  1630.     PRINTF("%s\n", slide);
  1631. #endif /* ?NATIVE */
  1632.  
  1633. } /* end function fnprint() */
  1634.